1. Field of the Invention
The present invention relates generally to the management of network content. More particularly, the present invention relates to updating network content using a content management system.
2. Background Art
As the user base of packet networks, such as the Internet, has broadened to include sophisticated vendors and consumers, ever greater importance has been placed on those networks as sources of advertising and entertainment. Savvy and increasingly demanding consumers desire to access frequently updated information, and have increasingly lofty expectations of the richness of web based content. Advertisers, seeking to meet these enhanced consumer expectations, have found the venerable Hypertext Markup Language (HTML) format used in much of early web design to be too constraining. As a result, more and more content has been developed using formats more enabling of the dynamic, rich media experience preferred by consumers. Embedded graphics applications such as Flash and Silverlight, for example, have made it possible for advertisers to provide the rich media content that consumers now demand.
However, conventional approaches to providing rich media content, such as rich web content, impose substantial burdens on both the graphical designers responsible for the look and feel of the content, and the content developers, i.e., programmers, charged with producing the application source code providing the rich media experience. FIG. 1 shows flowchart 100 of a process flow for producing and updating rich media content using a conventional approach. As shown in FIG. 1, the conventional process flow includes an iterative interaction between designers and programmers as rich media content is first provided, and later modified.
Beginning with step 110, a typical conventional approach to providing rich media content includes pre-determination of the display assets to be included in the content, followed by generation of the source code in step 120. Typically the predetermined display assets are specified in the source code, requiring that the designers anticipate a full menu of display assets prior to coding. In addition, the conventional approach requires that the programmers be sufficiently familiar with the aesthetic vision of the designers to appropriately capture the predetermined display assets in the coding.
Following steps 110 and 120, which, as described, often require joint effort on the part of the design and development teams, the source code is compiled in step 130 and the resulting rich media content is published in step 140. Thus, steps 110 through 140 typically require collaborative effort between graphical designers and programmers, and result in rich media content that is limited in expression to those display assets predetermined by the designers and coded by the developers. Subsequent changes to the display assets, such as re-skinning, or introducing theme and/or logo changes, for example, require going back into the source code to appropriately adjust the display assets defined within.
As a result, modifying rich media content according to the conventional approach requires repetition of steps similar to steps 110 through 140. That is to say, the changes or modifications to the pre-determined display assets are determined by the graphical designers in step 150, which echoes initial step 110. Then, the source code must be edited by the programmers to incorporate the new or modified definitions into the code in step 160. The code must be recompiled in step 170 and republished in step 180. Moreover, steps 150 through 180 must be repeated for additional modifications to the display assets made after republication in step 180.
In short, the conventional approach requires the participation of both designers and programmers for the delivery of rich media content, both during its production, and during its modification. In addition, the conventional approach requires that the two working groups, i.e., graphic designers and programmer, have a sufficient understanding of the discipline practiced by the other so that they may work in productive cooperation. Also, because the conventional approach typically requires changes to the source code for each instance of modification, those modifications require recompiling the source code and republishing the rich media content. Because modifying existing rich media content is such a burdensome undertaking according to the conventional approach, there are significant incentives to delay introduction of changes, and to batch changes so as to spread the resource costs for introducing content modifications over time.
The foregoing drawbacks of the conventional approach to producing and modifying rich media content have been described by reference to a single graphics environment. In some cases, however, it may desirable to make the same rich media content available across multiple graphics environments. For example, a producer of rich media content may desire to provide the content in a Flash format, due to Flash's penetration of personal computing platforms, and also in Java, for mobile device users seeking to enjoy the rich media experience. In that situation, in addition to the drawbacks described previously, are the significant disadvantages flowing from the need to support a duplication of the rich media content in the distinct graphics environments. Those additional disadvantages may include, for example, the resource commitments required to produce multiple versions of the content, as well as the problem of harmonizing the available display assets, so that updates and changes to content rendered in one graphics environment are appropriately reflected in the others.
Accordingly, there is a need to overcome the drawbacks and deficiencies in the art by presenting a solution enabling content designers to dynamically update graphical features of existing content, for example by means of a content management system, without requiring that the source code of the existing content be modified. It would additionally be advantageous for the solution to enable concurrent updating of existing content across multiple graphics environments.